home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 21 / AMIGAplus Sonderheft 21 (1999)(ICP)(DE)[!].iso / PublicDomain / Spiele / scott / source / Source.lha / AMIGA6.C next >
C/C++ Source or Header  |  1999-04-04  |  45KB  |  1,672 lines
  1. /*
  2.  *  AMIGA Libs & Functions for Scott-Free
  3.  *
  4.  *  ===================================================================
  5.  *
  6.  *  Version History AMIGA:
  7.  *  Ver ,     Date,     Author, Comment
  8.  *  -------------------------------------------------------------------
  9.  *  1.0 , 28/07/96, Andreas Aumayr, First public release
  10.  *  1.1 , 16/08/96, Andreas Aumayr, Added ToolType support & font prefs
  11.  *  1.2 , 30/08/96, Andreas Aumayr, ASL-FR for Load/Save/Datafile
  12.  *  1.3 , 08/09/96, Andreas Aumayr, Menus, loads of minor enhancements,
  13.  *                                  'real' command history, more TTs
  14.  *  1.4 , 17/09/96, Andreas Aumayr, Public screen support, more TTs, ..
  15.  *  1.5 and higher: Andreas Aumayr, just to lazy to keep track of changes :-)
  16.  *  ___________________________________________________________________
  17.  */
  18.  
  19. #define  MAX_HIST 20
  20. #define  MAX_LL   40
  21. #define  PIC       8
  22. #define  COC       7
  23. #define  OVL       6
  24. #define  ANI       5
  25. #define  GOT       4
  26.  
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <stdlib.h>
  30. #include <ctype.h>
  31. #include <stdarg.h>
  32. #include <time.h>
  33.  
  34. #include <exec/memory.h>
  35. #include <intuition/intuition.h>
  36. #include <graphics/GfxBase.h>
  37. #include <graphics/rpattr.h>
  38. #include <workbench/workbench.h>
  39. #include <libraries/dos.h>
  40. #include <libraries/dosextens.h>
  41. #include <dos/exall.h>
  42. #include <utility/tagitem.h>
  43. #include <libraries/asl.h>
  44. #include <libraries/gadtools.h>
  45. #include <workbench/startup.h>
  46. #include <libraries/amigaguide.h>
  47. #include <datatypes/pictureclass.h>
  48. #include <devices/inputevent.h>
  49. #include <exec/types.h>
  50. #include <exec/exec.h>
  51. #include <devices/narrator.h>
  52. #include <libraries/translator.h>
  53. #include "gui.c"
  54.  
  55. extern struct MsgPort *CreatePort();
  56. extern struct IORequest *CreateExtIO();
  57. ULONG  TranslatorBase;
  58. struct MsgPort *narratorPort;
  59. struct narrator_rb *request;
  60. STRPTR nartrans[1024];
  61. ULONG  narBuf;
  62. BYTE   channels[4] = {3,5,10,12};
  63. struct IntuitionBase *IntuitionBase;
  64. struct GfxBase *GfxBase;
  65. ULONG  DiskfontBase;
  66. ULONG  IconBase;
  67. ULONG  Dos_Base;
  68. ULONG  UtilityBase;
  69. ULONG  AslBase;
  70. ULONG  GadToolsBase;
  71. ULONG  AmigaGuideBase;
  72. ULONG  DataTypesBase;
  73. struct Screen *WBscreen = NULL;
  74. struct Screen *ScottScreen = NULL;
  75. ULONG  old_pubmode;
  76. struct Window *act_w_hdl;
  77. struct Window *pic_w_hdl = NULL;
  78. APTR   WBvisinfo = NULL;
  79. struct TextFont *textfont = NULL;
  80. char   save_game[32] = "";
  81. char   data_file[32] = "",data_dir[256] = "";
  82. char   save_dir[256] = "";
  83. char   gfx_file[256] = "";
  84. char   FFP[256];
  85.  
  86. char   hist[MAX_HIST][MAX_LL+1];
  87. int    hist_pos=0,hist_fill=0;
  88.  
  89. struct Menu *menu = NULL;
  90. char   Version[] = "$VER: AMIGA SCOTT-Free V1.8, 1996-99";
  91. char   GameInfoStr[256] = "";
  92.  
  93. struct WBStartup *WBMessage;
  94. struct MsgPort *OldUserPort;
  95. BOOL   WBSTART  = FALSE;
  96. BOOL   RESTART  = TRUE;
  97. BOOL   LINEWRAP = TRUE;
  98. BOOL   GFX      = TRUE;
  99. BOOL   SPEECH   = FALSE;
  100. ULONG  Disp_ID;
  101. BOOL   FASTCOLOURS = FALSE;
  102. //BOOL   NOGFXPOS = FALSE;
  103. //BOOL   INIT = FALSE;
  104. //BOOL   GFXDOUBLE = FALSE;
  105. char   restart_file[42] = "RAM:";
  106. BPTR   restart_lock;
  107.  
  108. struct NewAmigaGuide scott_guide = {NULL};
  109. int    last_pic = -128;
  110. room_pics *rp = 0;
  111. ULONG  *go = 0;
  112. LONG   Pens[16] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
  113. UBYTE  NumColours = 0;
  114. UBYTE  planesN = 0;
  115. struct ColorRegister CR[16];
  116. struct BitMap bitmapN;
  117. int    gfx_width = 0,gfx_height = 0;
  118. WORD   win_pos_ver,win_pos_hor;
  119. int    win_width = -1,win_height;
  120. BYTE   ScreenAspect;
  121. UBYTE  *picture = 0,*rle_dat = 0,*overlay = 0;
  122. WORD   w_top;
  123. int    nroom;
  124.  
  125. FILE   *gfx_in_file;
  126.  
  127. /// NoSpeech
  128. void NoSpeech(BYTE status)
  129. {
  130.     switch(status) {
  131.         case 0:
  132.             CloseDevice(request);
  133.         case 1:
  134.             DeleteExtIO(request);
  135.         case 2:
  136.             DeletePort(narratorPort);
  137.         case 3:
  138.             CloseLibrary(TranslatorBase);
  139.             TranslatorBase = 0;
  140.             SPEECH = FALSE;
  141.     }
  142. }///
  143.  
  144. /// close_libs
  145. void close_libs(void)
  146. {
  147.         if (TranslatorBase) NoSpeech(0);
  148.         if (AmigaGuideBase) CloseLibrary(AmigaGuideBase);
  149.         if (GadToolsBase) CloseLibrary(GadToolsBase);
  150.         if (AslBase) CloseLibrary(AslBase);
  151.         if (UtilityBase) CloseLibrary(UtilityBase);
  152.         if (Dos_Base) CloseLibrary(Dos_Base);
  153.         if (IconBase) CloseLibrary(IconBase);
  154.         if (DiskfontBase) CloseLibrary(DiskfontBase);
  155.         if (GfxBase) CloseLibrary(GfxBase);
  156.         if (IntuitionBase) CloseLibrary(IntuitionBase);
  157. }///
  158.  
  159. /// open_libs
  160. BOOL open_libs(void)
  161. {
  162.                 IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",37);
  163.                 if (IntuitionBase == NULL) {
  164.                         printf("Problems opening Intuition-Lib!\n");
  165.                         return(FALSE);
  166.                 }
  167.                 GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",37);
  168.                 if (GfxBase == NULL) {
  169.                         printf("Problems opening GFX-Lib!\n");
  170.                         return(FALSE);
  171.                 }
  172.                 DiskfontBase = OpenLibrary("diskfont.library",0);
  173.                 if (DiskfontBase == 0) {
  174.                         EasyRequest(NULL,&Library,NULL,"DiskFont");
  175.                         return(FALSE);
  176.                 }
  177.                 IconBase = OpenLibrary("icon.library",0);
  178.                 if (IconBase == 0) {
  179.                         printf("Problems opening Icon-Lib!\n");
  180.                         return(FALSE);
  181.                 }
  182.                 Dos_Base = OpenLibrary("dos.library",0);
  183.                 if (Dos_Base == 0) {
  184.                         printf("Problems opening DOS-Lib!\n");
  185.                         return(FALSE);
  186.                 }
  187.                 UtilityBase = OpenLibrary("utility.library",0);
  188.                 if (UtilityBase == 0) {
  189.                         printf("Problems opening Utility-Lib!\n");
  190.                         return(FALSE);
  191.                 }
  192.                 AslBase = OpenLibrary("asl.library",0);
  193.                 if (AslBase == 0) {
  194.                         EasyRequest(NULL,&Library,NULL,"ASL");
  195.                         return(FALSE);
  196.                 }
  197.                 GadToolsBase = OpenLibrary("gadtools.library",36);
  198.                 if (GadToolsBase == 0) {
  199.                         printf("Problems opening GadTools-Lib!\n");
  200.                         return(FALSE);
  201.                 }
  202.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  203.                 TranslatorBase = OpenLibrary("translator.library",0);
  204.                 if (TranslatorBase) {
  205.                     narratorPort = (struct MsgPort *) CreatePort(0,0);
  206.                     if (narratorPort == NULL) NoSpeech(3);
  207.                     else {
  208.                         request = (struct narrator_rb *) CreateExtIO(narratorPort, sizeof(struct narrator_rb));
  209.                         if (request == NULL) NoSpeech(2);
  210.                         else if (OpenDevice("narrator.device",0,request,0)) NoSpeech(1);
  211.                     }
  212.                 }
  213.                 return(TRUE);
  214. }///
  215.  
  216. ///FreeGFXRes
  217. void FreeGFXRes(void)
  218. {
  219.     int     i;
  220.  
  221.     if (gfx_in_file) fclose(gfx_in_file);
  222.     
  223.     if (rp) free(rp);
  224.     if (go) free(go);
  225.  
  226.     if (FASTCOLOURS) for (i=0;i<NumColours;i++) SetRGB4(&WBscreen->ViewPort,i,(Pens[i]&0x0F00)>>8,(Pens[i]&0x00F0)>>4,Pens[i]&0x000F);
  227.     else {
  228.         for (i=0; i<NumColours; i++) {
  229.             if (Pens[i] > 0) ReleasePen(WBscreen->ViewPort.ColorMap,Pens[i]);
  230.             else break;
  231.         }
  232.     }
  233.  
  234.     for (i=0; i<planesN; i++) {
  235.         if (bitmapN.Planes[i]) FreeRaster(bitmapN.Planes[i],gfx_width,gfx_height);
  236.         else break;
  237.     }
  238.  
  239.     if (picture) FreeMem(picture,gfx_width*gfx_height);
  240.     if (rle_dat) FreeMem(rle_dat,gfx_width*gfx_height);
  241.     if (overlay) FreeMem(overlay,gfx_width*gfx_height);
  242. }///
  243.  
  244. /// close_all
  245. void close_all(void)
  246. {
  247.     if (restart_lock) UnLock(restart_lock);
  248.     DeleteFile(restart_file);
  249.  
  250.     if (menu) FreeMenus(menu);
  251.     if (WBvisinfo) FreeVisualInfo(WBvisinfo);
  252.     if (WBscreen) UnlockPubScreen(NULL,WBscreen);
  253.     if (textfont) CloseFont(textfont);
  254.     if (pic_w_hdl) CloseWindow(pic_w_hdl);
  255.     if (act_hdl) {
  256.         act_w_hdl->UserPort = OldUserPort;
  257.         Close(act_hdl);
  258.     }
  259.     if (env_hdl) Close(env_hdl);
  260.  
  261.     if (GFX) FreeGFXRes();
  262.  
  263.     SetPubScreenModes(old_pubmode);
  264.     if (ScottScreen) {
  265.         while (CloseScreen(ScottScreen) == FALSE) EasyRequest(NULL,&ClosePub,NULL,NULL);
  266.     }
  267.     close_libs();
  268. }///
  269.  
  270. /// MemAlloc
  271. void * MemAlloc(int size)
  272. {
  273.     void *t = (void *) AllocMem(size,MEMF_ANY|MEMF_CLEAR);
  274.     if (t == NULL) {
  275.         printf("\nUnable to get some mem!\nTerminating.\n");
  276.         EasyRequest(NULL,&NoMem,NULL,NULL);
  277.         close_all();
  278.         exit(128);
  279.     }
  280.     return(t);
  281. }///
  282.  
  283. /// Open_CON
  284. struct FileHandle *Open_CON(char *type, int left_off, int top_off, int width, int height, char *title, char *flags, char *cscreen)
  285. {
  286.     sprintf(str_buf,"%s:%d/%d/%d/%d/%s/%s/SCREEN %s",type,left_off,top_off,width,height,title,flags,cscreen);
  287.     CON_handle = (struct FileHandle *) Open(str_buf,MODE_NEWFILE);
  288.     if (!CON_handle) {
  289.         printf("Failed to open console window '%s'!\n",title);
  290.         EasyRequest(NULL,&ConFail,NULL,title);
  291.         close_all();
  292.         exit(99);
  293.     }
  294.     else return(CON_handle);
  295. }///
  296.  
  297. ///dyn_strings
  298. void * dyn_strings(char *cont, BYTE add)
  299. {
  300.         void *mem_ptr;
  301.  
  302.         if (cont && strlen(cont)) {
  303.                 mem_ptr = MemAlloc(strlen(cont)+1+add);
  304.                 strcpy(mem_ptr,cont);
  305.                 //printf("MemPtr: |%s| at %ld\n",mem_ptr,mem_ptr);
  306.                 return(mem_ptr);
  307.         }
  308.         return(NULL);
  309. }///
  310.  
  311. ///Get_TT
  312. BOOL Get_TT(char *file_name, UWORD *font_size, char **font_name, char *data_file, char *data_dir, char **cscreen)
  313. {
  314.     char    **tt_base,*fn,file_dir[256] = "";
  315.     struct  DiskObject *diskobj;
  316.     BOOL    tandy = FALSE;
  317.     BYTE    lw;
  318.  
  319.     if (WBSTART) {
  320.         NameFromLock(WBMessage->sm_ArgList->wa_Lock,file_dir,255);
  321.         Make_FFP(file_name,file_dir);
  322.     }
  323.     else strcpy(FFP,file_name);
  324.  
  325.     if ((diskobj = (struct DiskObject *) GetDiskObject(FFP))) {
  326.         tt_base = diskobj->do_ToolTypes;
  327.         fn = (char *) FindToolType(tt_base,"FONT_NAME");
  328.         if (fn) {
  329.             *font_name = dyn_strings(fn,5);
  330.             strcat(*font_name,".font");
  331.             *font_size = (UWORD) abs(atoi((char *) FindToolType(tt_base,"FONT_SIZE")));
  332.         }
  333.         *cscreen = dyn_strings((char *) FindToolType(tt_base,"PUBLICSCREEN"),0);
  334.         if (FindToolType(tt_base,"ADV_DATAFILE")) strncpy(data_file,(char *) FindToolType(tt_base,"ADV_DATAFILE"),31);
  335.         if (FindToolType(tt_base,"ADV_DIR")) {
  336.             Make_FFP((char *) FindToolType(tt_base,"ADV_DIR"),file_dir);
  337.             strncpy(data_dir,FFP,255);
  338.         }
  339.         if (FindToolType(tt_base,"SAVE_GAME")) strncpy(save_game,(char *) FindToolType(tt_base,"SAVE_GAME"),31);
  340.         if (FindToolType(tt_base,"SAVE_DIR")) {
  341.             Make_FFP((char *) FindToolType(tt_base,"SAVE_DIR"),file_dir);
  342.             strncpy(save_dir,FFP,255);
  343.         }
  344.         lw = (BYTE) abs(atoi((char *) FindToolType(tt_base,"LINEWIDTH")));
  345.         if ((lw > 0) && (lw <= 99)) Width = lw;
  346.         if (Strnicmp(FindToolType(tt_base,"TANDYFLAG"),"ON",2) == 0) tandy = TRUE;
  347.         if (Strnicmp(FindToolType(tt_base,"FASTCOLOURS"),"ON",2) == 0) FASTCOLOURS = TRUE;
  348.         if (Strnicmp(FindToolType(tt_base,"LINEWRAP"),"OFF",3) == 0) LINEWRAP = FALSE;
  349.         Disp_ID = strtoul((char *) FindToolType(tt_base,"DISPLAY"),NULL,0);
  350.         //printf("|%s|, |%s|, |%s|, |%s|, |%s,%d|, |%s|\n",save_game,save_dir,data_file,data_dir,*font_name,*font_size,*cscreen);
  351.         if (FindToolType(tt_base,"SPEECH") && TranslatorBase) SPEECH = TRUE;
  352.         FreeDiskObject(diskobj);
  353.     }
  354.     else {
  355.         *font_name = dyn_strings("",0);
  356.         *cscreen   = dyn_strings("",0);
  357.     }
  358.     return(tandy);
  359. }///
  360.  
  361. /// Get_Font
  362. void Get_Font(UWORD font_ysize, char *font_name)
  363. {
  364.     struct TextAttr textattr;
  365.  
  366.     textattr.ta_Name =  font_name;
  367.     textattr.ta_YSize = font_ysize;
  368.     textattr.ta_Style = FS_NORMAL;
  369.     textattr.ta_Flags = FPF_DISKFONT|FPF_DESIGNED;
  370.     if ((textfont = (struct TextFont *) OpenDiskFont(&textattr))) {
  371.         if (textfont->tf_Flags & FPF_PROPORTIONAL) {
  372.             EasyRequest(NULL,&NoProp,NULL,textfont->tf_Message.mn_Node.ln_Name);
  373.             close_all();
  374.             Exit(50);
  375.         }
  376.     }
  377. }///
  378.  
  379. /// Set_NewFont
  380. void Set_NewFont(void)
  381. {
  382.         struct Window *win, *env_w_hdl = NULL;
  383.  
  384.         win = WBscreen->FirstWindow;
  385.         do {
  386.                 if (strncmp(win->Title,"Environment",11) == 0) env_w_hdl = win;
  387.                 if (strncmp(win->Title,"SCOTT-Free AMIGA",16) == 0) act_w_hdl = win;
  388.                 if ((env_w_hdl) && (act_w_hdl)) break;
  389.         } while ((win = win->NextWindow));
  390.  
  391.         if (textfont) {
  392.             SetFont(act_w_hdl->RPort,textfont);
  393.             SetFont(env_w_hdl->RPort,textfont);
  394.         }
  395. }///
  396.  
  397. /// Make_FFP
  398. void Make_FFP(char *file, char *dir)
  399. {
  400.   strcpy(FFP,dir);
  401.   AddPart(FFP,file,256);
  402. }///
  403.  
  404. /// Get_FileList
  405. /*
  406. void Get_FileList(char *dir, char **dfile_names, BYTE *cnt, BYTE mode)
  407. {
  408.     BPTR    dir_lock;
  409.     struct  FileInfoBlock *dfib;
  410.     APTR    pat;
  411.     char    dname[256];
  412.     static  BYTE cc = 0;
  413.  
  414.     if ((dir_lock = Lock(dir,SHARED_LOCK))) {
  415.         if ((dfib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  416.             if (Examine(dir_lock,dfib)) {
  417.                 pat = MemAlloc(12);
  418.                 ParsePatternNoCase("#?.dat",pat,12);
  419.                 while(ExNext(dir_lock,dfib)) {
  420.                     if (dfib->fib_DirEntryType == ST_USERDIR) {
  421.                         strcpy(dname,dir);
  422.                         AddPart(dname,dfib->fib_FileName,256);
  423.                         switch (mode) {
  424.                           case 0:
  425.                             Get_FileList(dname,NULL,cnt,0);
  426.                             break;
  427.                           case 1:
  428.                             Get_FileList(dname,dfile_names,NULL,1);
  429.                             break;
  430.                           default:
  431.                             break;
  432.                         }
  433.                     }
  434.                     if (dfib->fib_DirEntryType == ST_FILE && MatchPatternNoCase(pat,dfib->fib_FileName)) {
  435.                         switch (mode) {
  436.                           case 0:
  437.                             (*cnt)++;
  438.                             break;
  439.                           case 1:
  440.                             Make_FFP(dfib->fib_FileName,dir);
  441.                             dfile_names[cc++] = dyn_strings(FFP,0);
  442.                             break;
  443.                           default:
  444.                             break;
  445.                         }
  446.                     }
  447.                 }
  448.                 free(pat);
  449.             }
  450.             FreeDosObject(DOS_FIB,dfib);
  451.         }
  452.         UnLock(dir_lock);
  453.     }
  454. }*/
  455. ///
  456.  
  457. ///Open_ASL
  458. BOOL Open_ASL(char *file_name, char *dir_name, UBYTE mode)
  459. {
  460.    struct TagItem *ASLTags;
  461.    struct FileRequester *FileRequester;
  462.    LONG   areq;
  463.  
  464.    FileRequester = (struct FileRequester *) AllocAslRequest(ASL_FileRequest,NULL);
  465.    if (FileRequester == NULL) return(FALSE);
  466.    ASLTags = (struct TagItem *) AllocateTagItems(8);
  467.    if (ASLTags == NULL) {
  468.            FreeFileRequest(FileRequester);
  469.            return(FALSE);
  470.    }
  471.    ASLTags[0].ti_Tag = ASLFR_InitialPattern;
  472.    ASLTags[0].ti_Data = (ULONG) "#?.save";
  473.    if (mode == 2) ASLTags[0].ti_Data = (ULONG) "#?.dat";
  474.    ASLTags[1].ti_Tag = ASLFR_Flags1;
  475.    ASLTags[1].ti_Data = FRF_DOPATTERNS;
  476.    if (mode == 1) ASLTags[1].ti_Data = FRF_DOPATTERNS|FRF_DOSAVEMODE;
  477.    ASLTags[2].ti_Tag = ASLFR_TitleText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  478.    ASLTags[2].ti_Data = (ULONG) "Restore Save-Game";
  479.    if (mode == 1) ASLTags[2].ti_Data = (ULONG) "Save Game as ...";
  480.    if (mode == 2) ASLTags[2].ti_Data = (ULONG) "Choose Adventure-DataFile";
  481.    ASLTags[3].ti_Tag = ASLFR_InitialFile;
  482.    ASLTags[3].ti_Data = (ULONG) file_name;
  483.    ASLTags[4].ti_Tag = ASLFR_InitialDrawer;
  484.    ASLTags[4].ti_Data = (ULONG) dir_name;
  485.    ASLTags[5].ti_Tag = ASLFR_PositiveText; // 0: Restore Game, 1: Save Game, 2: Choose Adventure
  486.    ASLTags[5].ti_Data = (ULONG) "Load";
  487.    if (mode == 1) ASLTags[5].ti_Data = (ULONG) "Save";
  488.    if (mode == 2) ASLTags[5].ti_Data = (ULONG) "Play";
  489.    ASLTags[6].ti_Tag = ASLFR_Window;
  490.    ASLTags[6].ti_Data = (ULONG) act_w_hdl;
  491.    ASLTags[7].ti_Tag = TAG_DONE;
  492.    if ((areq = AslRequest(FileRequester,ASLTags))) {
  493.                 strcpy(file_name,FileRequester->fr_File);
  494.                 strcpy(dir_name,FileRequester->fr_Drawer);
  495.                 //printf("Dir, File: %s, %s\n",FileRequester->fr_File,FileRequester->fr_Drawer);
  496.    }
  497.    FreeTagItems(ASLTags);
  498.    FreeFileRequest(FileRequester);
  499.    if (areq) return(TRUE);
  500.    return(FALSE); // Cancel pressed or ASL-problem
  501. }///
  502.  
  503. /// Get_FileSize
  504. /*
  505. LONG Get_FileSize(BPTR file_lock)
  506. {
  507.         struct  FileInfoBlock *ffib;
  508.  
  509.         if ((ffib = (struct FileInfoBlock *) AllocDosObject(DOS_FIB,NULL))) {
  510.                 if (Examine(file_lock,ffib)) {
  511.                         printf("Name: %s\nSize: %d\n",ffib->fib_FileName,ffib->fib_Size);
  512.                 }
  513.                 FreeDosObject(DOS_FIB,ffib);
  514.                 return(ffib->fib_Size);
  515.         }
  516.         return(0);
  517. } */
  518. ///
  519.  
  520. /// Show_FileList
  521. /*
  522. void Show_FileList(char *dir)
  523. {
  524.         char **dfile_names;
  525.         BYTE i,cnt = 0;
  526.  
  527.         Get_FileList(dir,NULL,&cnt,0);
  528.         dfile_names = (char **) MemAlloc(sizeof(char *) * cnt);
  529.         Get_FileList(dir,dfile_names,NULL,1);
  530.         for (i=0;i<=cnt-1;i++) {
  531.                 printf("%2d: %10.*s [%s]\n",i,(int)strlen(FilePart(dfile_names[i]))-4,FilePart(dfile_names[i]),dfile_names[i]);
  532.         }
  533.         if (cnt > 0) for (i=0;i<=cnt-1;i++) free(dfile_names[cnt]);
  534.         free(dfile_names);
  535. }*/
  536. ///
  537.  
  538. /// Open_File
  539. FILE * Open_File(char * file_name)
  540. {
  541.     FILE    *f;
  542.  
  543.     if ((f = fopen(file_name,"r")) == NULL) {
  544.         perror(file_name);
  545.         EasyRequest(NULL,&FError,NULL,file_name);
  546.         close_libs();
  547.         exit(1);
  548.     }
  549.     strcat(restart_file,(char *)FilePart(file_name));
  550.     strcat(restart_file,".res");
  551.     return(f);
  552. }///
  553.  
  554. /// Get_AdvFile
  555. FILE * Get_AdvFile(char *data_file, char *data_dir)
  556. {
  557.     BPTR    lock;
  558.  
  559.     if (strcmp(data_file,"") == 0) strcpy(data_file,".dat");
  560.     Make_FFP(data_file,data_dir);
  561.     while ((lock = Lock(FFP,SHARED_LOCK)) == NULL) {
  562.         if (Open_ASL(data_file,data_dir,2) == FALSE) return(NULL);
  563.         //    close_all();
  564.         //    exit(64);
  565.         //}
  566.         Make_FFP(data_file,data_dir);
  567.     }
  568.     UnLock(lock);
  569.     return(Open_File(FFP));
  570. }///
  571.  
  572. /// GFX_Off
  573. void GFX_Off(void)
  574. {
  575.     GFX = FALSE;
  576.     OffMenu(act_w_hdl,63491);
  577. }///
  578.  
  579. ///Get_GFXSize
  580. void Get_GFXSize(void)
  581. {
  582.     gfx_in_file = fopen(gfx_file,"rb");
  583.     if (gfx_in_file == NULL) {
  584.         //printf("No GFX\n");
  585.         GFX = FALSE;
  586.         return;
  587.     }
  588.  
  589.     // Fetch GFX size from binary file
  590.     gfx_width = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file);
  591.     gfx_height = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file);
  592.     //printf("GFX-Size: %d x %d Pixel.\n",gfx_width,gfx_height);
  593.  
  594. }///
  595.  
  596. ///Get_PicLog
  597. void Get_PicLog(void)
  598. {
  599.     int           i,j = 0,k,kk,rnum,count,nac89;
  600.     unsigned char in_dat[1024];
  601.  
  602.     nroom = fgetc(gfx_in_file); // Number of rooms (maybe +1 if showPIC starts with 0 and not 1 !!!)
  603.     nac89 = fgetc(gfx_in_file); // Number of Action89 pics
  604.     fgetc(gfx_in_file); // Number of extended room pics
  605.     
  606.     // Read pic offset in bytes/room
  607.     count = fgetc(gfx_in_file);
  608.     //printf("\n%d Offsets\n",count);
  609.     //if (count != npics) printf("Serious prob in gfx file\n. Let's wait for the GURU :-)\n");
  610.     //printf("Speicher1: %ld\n",*go);
  611.     go = malloc(sizeof(unsigned long)  * count);
  612.     //printf("Speicher2: %ld\n",*go);
  613.     fread(&in_dat[0],1,count*3,gfx_in_file);
  614.     for (i=0; i<count; i++) {
  615.         go[i] = (unsigned long) in_dat[i*3]*256*256 + (unsigned long) in_dat[i*3+1]*256 + in_dat[i*3+2];
  616.         //printf("GFX-OFF%d: %7ld\n",i,go[i]);
  617.     }
  618.     
  619.     rp = malloc(sizeof(room_pics) * (nroom+nac89+1)); //pic0 is black (darkness)
  620.     for (i=0; i<=nroom+nac89; i++) rp[i].ppr = 0;
  621.  
  622.     count = fgetc(gfx_in_file)*256 + fgetc(gfx_in_file); // how many BYTES!!! for room logic
  623.     //printf("%d Logic Bytes\n",count);
  624.     fread(&in_dat[0],1,count,gfx_in_file);
  625.     while (j<count) {
  626.         rnum = in_dat[j++];
  627.         rp[rnum].ppr = in_dat[j++];
  628.         if (rp[rnum].ppr > MAX_PPR) { // Byte 2: How many pics/room (except default pic)
  629.             GFX_Off();
  630.             EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrupt\nor wrong datafile (PPR).\nGFX will be switched off.");
  631.             return;
  632.         }
  633.         //printf("\nRoom: %2d (%2d Pics)\n ",rnum,rp[rnum].ppr);
  634.         for (i=0; i<rp[rnum].ppr; i++) {
  635.             rp[rnum].what[i] = in_dat[j++];
  636.             kk = rp[rnum].what[i]-80;
  637.             while (kk < 0) kk += 10;
  638.             if (kk > MAX_LOG) {
  639.                 GFX_Off();
  640.                 EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrupt\nor wrong datafile (LOG).\nGFX will be switched off.");
  641.                 return;
  642.             }
  643.             for (k=0; k<kk; k++) {
  644.                 rp[rnum].loc[i][k] = in_dat[j++];
  645.                 rp[rnum].obj[i][k] = in_dat[j++];
  646.                 //printf("Ob%d|%d: %2d,Loc%d: %d - ",i,k,rp[rnum].obj[i][k],i,rp[rnum].loc[i][k]);
  647.             }
  648.             rp[rnum].pnr[i] = in_dat[j++]; // picture number to display if condition is TRUE
  649.         }
  650.     }
  651.     //close_all();
  652.     //exit(0);
  653. }
  654. ///
  655.  
  656. /// Init_Win
  657. void Init_Win(struct FileHandle *win, BYTE fg, BYTE bg)
  658. {
  659.         CON_handle = win;
  660.         clrsys();
  661.         background(bg);
  662.         textcolor(fg,bg);
  663.         cursor(FALSE);
  664. }///
  665.  
  666. /// Open_Wins
  667. void Open_Wins(UWORD fy_size, char **font_name, char *cscreen)
  668. {
  669.         WORD    w_height_gfx,w_height_env,w_height_act,w_width,w_left;
  670.         UWORD   fx_size;
  671.         struct  Screen *DefPubScr;
  672.         //char    DefPubScrName[256];
  673.  
  674.         if (fy_size) Get_Font(fy_size,*font_name);
  675.         free(*font_name);
  676.         free(font_name);
  677.         if (textfont) fx_size = (UWORD) textfont->tf_XSize;
  678.         else {
  679.             DefPubScr = (struct Screen *) LockPubScreen("Workbench");
  680.             fx_size = DefPubScr->FirstWindow->IFont->tf_XSize;
  681.             fy_size = DefPubScr->FirstWindow->IFont->tf_YSize;
  682.             //printf("X: %d, Y: %d (%s)\n",fx_size,fy_size,DefPubScr->FirstWindow->IFont->tf_Message.mn_Node.ln_Name);
  683.             if (DefPubScr) UnlockPubScreen("Workbench",NULL);
  684.         }
  685.         w_width = (WORD) (Width * fx_size + (BYTE) WBscreen->WBorLeft + (BYTE) WBscreen->WBorRight);
  686.         w_height_env = (WORD) (TopHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
  687.         w_height_act = (WORD) (BottomHeight * fy_size + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 2);
  688.         w_height_gfx = (WORD) (gfx_height + (BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + WBscreen->WBorBottom + 1);
  689.         w_left = (WORD) (WBscreen->Width - w_width) / 2;
  690.         w_top = (WORD) (WBscreen->Height - w_height_env - w_height_act - w_height_gfx) / 2 + w_height_gfx;
  691.         if ((w_top + w_height_env + w_height_act) > WBscreen->Height) w_top = WBscreen->Height - w_height_env - w_height_act;
  692.         if ((w_width > WBscreen->Width) || ((w_height_env+w_height_act) > WBscreen->Height)) {
  693.             EasyRequest(NULL,&BigWins,NULL,NULL);
  694.             close_all();
  695.             exit(20);
  696.         }
  697.         env_hdl = Open_CON("RAW",w_left,w_top,w_width,w_height_env,"Environment","NOSIZE",cscreen);
  698.         act_hdl = Open_CON("CON",w_left,w_top+w_height_env,w_width,w_height_act,"SCOTT-Free AMIGA","NOSIZE/CLOSE",cscreen);
  699.         Set_NewFont();
  700.         Init_Win(env_hdl,WHITE,BLUE);
  701.         Init_Win(act_hdl,BLACK,GREY);
  702.  
  703.         scott_guide.nag_Screen = act_w_hdl->WScreen;
  704.         OldUserPort = act_w_hdl->UserPort;
  705.         act_w_hdl->UserPort = 0;
  706.         ModifyIDCMP(act_w_hdl,MENUPICK|RAWKEY|VANILLAKEY|CLOSEWINDOW|NEWSIZE);
  707.         menu = (struct Menu *) CreateMenus(newmenu,TAG_DONE);
  708.         LayoutMenus(menu,WBvisinfo,TAG_DONE);
  709.         SetMenuStrip(act_w_hdl,menu);
  710. }///
  711.  
  712. /// Size_Wins
  713. void Size_Wins(BOOL tandy)
  714. {
  715.         if (tandy) {
  716.                 Width = 64;
  717.                 TopHeight = 11;
  718.                 BottomHeight = 13;
  719.                 Options|=TRS80_STYLE;
  720.         }
  721.         else {
  722.                 if (Width == 0) Width = 80;
  723.                 TopHeight = 10;
  724.                 BottomHeight = 15;
  725.         }
  726. }///
  727.  
  728. /// copyright
  729. void copyright(void)
  730. {
  731.     OutReset();
  732.     OutBuf("AMIGA SCOTT-Free Version 1.8, 1996-99\n");
  733.     Speak("AMIGA SCOTT-Free Version 1.8, 1996 to 99");
  734.     OutBuf("© Andreas Aumayr, anden@ping.at\n\n");
  735.     Speak("copyright Andreas Aumayr, anden at ping point a t");
  736.     OutBuf("Based on SCOTT-Free UNIX/DOS V1.14b, © Alan Cox\n\n");
  737.     Speak("Based on SCOTT-Free UNIX/DOS V1.14b, copyright Alan Cox");
  738. }///
  739.  
  740. /// FirstOfAll
  741. void FirstOfAll(FILE *f)
  742. {
  743.     copyright();
  744.     OutBuf("Loading adventure data file ...  ");
  745.     Speak("Loading adventure data file");
  746.     LoadDatabase(f,(Options&DEBUGGING)?1:0);
  747.     fclose(f);
  748.     OutBuf("Finished.\n\n");
  749.     Speak("Finished.");
  750.     if (SaveRestart()) {
  751.         OffMenu(act_w_hdl,63649);
  752.         RESTART = FALSE;
  753.     }
  754. } ///
  755.  
  756. /// Restart
  757. void Restart(void)
  758. {
  759.     WriteCON(CLRSCR);
  760.     BitFlags = 0;
  761.     LoadRestart();
  762.     WriteCON("Restarting ...\n\n");
  763.     Speak("Restarting.");
  764.     Delay(20);
  765.     copyright();
  766.     PerformActions(0,0);
  767.     Look();
  768.     //strcpy(command,"");
  769. } ///
  770.  
  771. /// Init
  772. void Init(char *prog_name, char *adv_file, char *save_file)
  773. {
  774.     UWORD   fy_size = 0;
  775.     char    **font_name = (char **) MemAlloc(sizeof(char *));
  776.     char    **cscreen = (char **) MemAlloc(sizeof(char *));
  777.     FILE    *f;
  778.  
  779.     if (open_libs() == FALSE) {
  780.         close_libs();
  781.         exit(255);
  782.     }
  783.  
  784.     Size_Wins(Get_TT(prog_name,&fy_size,font_name,data_file,data_dir,cscreen));
  785.     if (Options & TRS80_STYLE) Size_Wins(TRUE);
  786.  
  787.     old_pubmode = SetPubScreenModes(POPPUBSCREEN);
  788.  
  789.     if (strcmp(adv_file,"") != NULL) {
  790.         strcpy(data_file,adv_file);
  791.         strcat(data_file,".dat");
  792.         f = Open_File(data_file);
  793.         strcat(strncpy(gfx_file,data_file,strlen(data_file)-4),".gfx");
  794.     }
  795.     else {
  796.         strcat(data_file,".dat");
  797.         if ((f = Get_AdvFile(data_file,data_dir)) == NULL) {
  798.             close_all();
  799.             exit(64);
  800.         }
  801.         strcat(strncpy(gfx_file,data_file,strlen(data_file)-4),".gfx");
  802.         Make_FFP(gfx_file,data_dir);
  803.         strcpy(gfx_file,FFP);
  804.     }
  805.     //printf("\n%s (%s - %s)\n",gfx_file,data_file,data_dir);
  806.  
  807.     if (Disp_ID) {
  808.         WORD D3Pens[] = {-1};
  809.         ScottScreen = (struct Screen *) OpenScreenTags(0,SA_Pens,D3Pens,SA_Depth,4,SA_DisplayID,Disp_ID,
  810.         SA_Type,PUBLICSCREEN,SA_Overscan,OSCAN_TEXT,SA_Title,"SCOTT-Free",SA_SysFont,1,
  811.         SA_PubName,"SCOTT-Free", SA_PubSig,0,SA_PubTask,NULL,TAG_DONE);
  812.         //SA_Interleaved,1, --> V39+
  813.         if (ScottScreen) {
  814.             PubScreenStatus(ScottScreen,0);
  815.             if (*cscreen) free(*cscreen);
  816.             *cscreen = dyn_strings("SCOTT-Free",0);
  817.         }
  818.         else EasyRequest(NULL,&NoScreen,NULL,NULL);
  819.     }
  820.  
  821.     if ((WBscreen = (struct Screen *) LockPubScreen(*cscreen)) == NULL) WBscreen = (struct Screen *) LockPubScreen("Workbench");
  822.     if (WBscreen) {
  823.         if ((WBvisinfo  = (APTR) GetVisualInfo(WBscreen,NULL))) {
  824.             
  825.             //Show_FileList(data_dir);
  826.             
  827.             Get_GFXSize();
  828.  
  829.             //if ((WBscreen->Width / WBscreen->Height) > 1) GFXDOUBLE = TRUE;
  830.  
  831.             Open_Wins(fy_size,font_name,*cscreen);
  832.             if (*cscreen) free(*cscreen);
  833.             free(cscreen);
  834.             
  835.             if (GFX) Get_PicLog();
  836.             else OffMenu(act_w_hdl,63491);
  837.             if (GFX) Init_GFX();
  838.  
  839.             if (TranslatorBase) {
  840.                 narBuf = sizeof(nartrans);
  841.                 request->message.io_Message.mn_ReplyPort = narratorPort;
  842.                 request->message.io_Command = CMD_WRITE;
  843.                 request->message.io_Data = (APTR) nartrans;
  844.                 request->rate = 160;
  845.                 request->pitch = DEFPITCH;
  846.                 request->sex = FEMALE;
  847.                 request->ch_masks = channels;
  848.                 request->nm_masks = sizeof(channels);
  849.                 request->volume = 64;
  850.             }
  851.             else OffMenu(act_w_hdl,63523);
  852.             if (SPEECH) ((struct MenuItem *) ItemAddress(menu,63523))->Flags |= CHECKED;
  853.  
  854.             FirstOfAll(f);
  855.  
  856.             if (strcmp(save_file,"") != NULL) LoadGame(save_file);
  857.             else if (strcmp(save_game,"") != NULL) {
  858.                 Make_FFP(save_game,save_dir);
  859.                 LoadGame(FFP);
  860.             }
  861.             else {
  862.                 strncpy(save_game,data_file,strlen(data_file)-4);
  863.                 strcat(save_game,".save");
  864.             }
  865.  
  866.             if (AmigaGuideBase) scott_guide.nag_Name = "Scott.guide";
  867.  
  868.             return;
  869.         }
  870.         printf("\nProblems getting Visual Info for screen '%s'!\n",*cscreen);
  871.         close_all();
  872.     }
  873.     printf("\nProblems locking custom screen '%s'\n",*cscreen);
  874.     close_libs();
  875. }///
  876.  
  877. /// NewGame
  878. BOOL NewGame(void)
  879. {
  880.     FILE    *f;
  881.  
  882.     strcpy(data_file,".dat");
  883.     if ((f = Get_AdvFile(data_file,data_dir)) == NULL) return(FALSE);
  884.     strncpy(gfx_file,data_file,strlen(data_file)-4);
  885.     gfx_file[strlen(data_file)-4] = 0;
  886.     strcat(gfx_file,".gfx");
  887.     Make_FFP(gfx_file,data_dir);
  888.     strcpy(gfx_file,FFP);
  889.     //printf("%s\n",gfx_file);
  890.  
  891.     if (restart_lock) UnLock(restart_lock);
  892.     DeleteFile(restart_file);
  893.  
  894.     if (GFX) {
  895.         if (pic_w_hdl) {
  896.             CloseWindow(pic_w_hdl);
  897.             pic_w_hdl = 0;
  898.         }
  899.         FreeGFXRes();
  900.     }
  901.  
  902.     //printf("Get New GFX File\n");
  903.     //if (!NOGFXPOS) {
  904.         GFX = TRUE;
  905.         OnMenu(act_w_hdl,63491);
  906.         Get_GFXSize();
  907.         if (!GFX) OffMenu(act_w_hdl,63491);
  908.         else Get_PicLog();
  909.         if (GFX) Init_GFX();
  910.     //}
  911.  
  912.     BitFlags = 0;
  913.     strcpy(GameInfoStr,"");
  914.  
  915.     WriteCON(CLRSCR);
  916.     FirstOfAll(f);
  917.  
  918.     strncpy(save_game,data_file,strlen(data_file)-4);
  919.     save_game[strlen(data_file)-4] = 0;
  920.     strcat(save_game,".save");
  921.     //printf("%s\n",save_game);
  922.  
  923.     srand(time(NULL));
  924.     return(TRUE);
  925. }///
  926.  
  927. /// Menu_Handle
  928. BOOL Menu_Handle(int code, char *command)
  929. {
  930.     //strcpy(command,"");
  931.     //printf("Packed, Menu, Item, SubItem, Address: %d, %d, %d, %d, %d\n",code,MENUNUM(code),ITEMNUM(code),SUBNUM(code),(struct MenuItem *) ItemAddress(menu,code));
  932.     if (MENUNUM(code) != MENUNULL) {
  933.         switch(MENUNUM(code)) {
  934.             case 0:
  935.                 switch(ITEMNUM(code)) {
  936.                     case 0:
  937.                         EasyRequest(act_w_hdl,&About,NULL,NULL);
  938.                         return(FALSE);
  939.                         break;
  940.                     case 2:
  941.                         if (NewGame()) {
  942.                             PerformActions(0,0);
  943.                             Look();
  944.                             strcpy(command,"");
  945.                             return(TRUE);
  946.                         }
  947.                         else return(FALSE);
  948.                         break;
  949.                     case 4:
  950.                         if (AmigaGuideBase) {
  951.                             CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  952.                         }
  953.                         return(FALSE);
  954.                         break;
  955.                     case 6:
  956.                         if (EasyRequest(act_w_hdl,&Quit,NULL,"")) {
  957.                             close_all();
  958.                             exit(0);
  959.                         }
  960.                         return(FALSE);
  961.                         break;
  962.                 }
  963.                 break;
  964.             case 1:
  965.                 switch(ITEMNUM(code)) {
  966.                     case 0:
  967.                         EasyRequest(act_w_hdl,&GameInfo,NULL,GameInfoStr);
  968.                         return(FALSE);
  969.                         break;
  970.                     case 2:
  971.                         strcpy(command,"!RESTORE");
  972.                         WriteCON("!RESTORE\n");
  973.                         return(TRUE);
  974.                         break;
  975.                     case 3:
  976.                         strcpy(command,"SAVE GAME");
  977.                         WriteCON("SAVE GAME\n");
  978.                         return(TRUE);
  979.                         break;
  980.                     case 5:
  981.                         Restart();
  982.                         strcpy(command,"");
  983.                         return(TRUE);
  984.                         break;
  985.                 }
  986.                 break;
  987.             case 2:
  988.                 switch(ITEMNUM(code)) {
  989.                     case 0:
  990.                         strcpy(command,"LOOK");
  991.                         WriteCON("LOOK\n");
  992.                         return(TRUE);
  993.                         break;
  994.                     case 1:
  995.                         strcpy(command,"INVENTORY");
  996.                         WriteCON("INVENTORY\n");
  997.                         return(TRUE);
  998.                         break;
  999.                     case 2:
  1000.                         strcpy(command,"GET ALL");
  1001.                         WriteCON("GET ALL\n");
  1002.                         return(TRUE);
  1003.                         break;
  1004.                     case 4:
  1005.                         strcpy(command,"SCORE");
  1006.                         WriteCON("SCORE\n");
  1007.                         return(TRUE);
  1008.                         break;
  1009.                 }
  1010.                 break;
  1011.             case 3:
  1012.                 switch(ITEMNUM(code)) {
  1013.                     case 0:
  1014.                         GFX = (GFX)?FALSE:TRUE;
  1015.                         if (GFX == FALSE) {
  1016.                             WriteCON("\n- Graphics are OFF now.\nTell me what to do ? ");
  1017.  
  1018.                             if (pic_w_hdl) {
  1019.                                 win_pos_ver = pic_w_hdl->LeftEdge;
  1020.                                 win_pos_hor = pic_w_hdl->TopEdge;
  1021.                                 CloseWindow(pic_w_hdl);
  1022.                                 pic_w_hdl = 0;
  1023.                             }
  1024.                         }
  1025.                         else {
  1026.                             WriteCON("\n- Graphics are ON now.\nTell me what to do ? ");
  1027.                             last_pic = -128;
  1028.                             Look();
  1029.                         }
  1030.                         return(FALSE);
  1031.                         break;
  1032.                     case 1:
  1033.                         SPEECH = (SPEECH)?FALSE:TRUE;
  1034.                         if (SPEECH == FALSE) WriteCON("\n- Speech is OFF now.\nTell me what to do ? ");
  1035.                         else {
  1036.                             WriteCON("\n- Speech is ON now.\nTell me what to do ? ");
  1037.                             Speak("Speech is ON now. Tell me what to do?");
  1038.                         }
  1039.                         return(FALSE);
  1040.                         break;
  1041.                 }
  1042.         }
  1043.     }
  1044.     return(FALSE);
  1045. }///
  1046.  
  1047. /// LineInput2
  1048. void LineInput2(char *command)
  1049. {
  1050.     UWORD       code,qual;
  1051.     ULONG       class;
  1052.     struct      IntuiMessage *mess;
  1053.     char        buf[MAX_LL+1],ncom[MAX_LL+1];
  1054.     int         len=0,c_pos=0,h_pos;
  1055.  
  1056.     h_pos = hist_pos;
  1057.     do {
  1058.         WaitPort(act_w_hdl->UserPort);
  1059.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  1060.             class = mess->Class;
  1061.             code  = mess->Code;
  1062.             qual  = mess->Qualifier;
  1063.             GT_ReplyIMsg(mess);
  1064.             switch (class) {
  1065.                 case IDCMP_VANILLAKEY:
  1066.                     if ((code >=32) && (code <=126)) {
  1067.                         if (len < MAX_LL) {
  1068.                             if (len != c_pos) {
  1069.                                 strcpy(buf,&hist[hist_pos][c_pos]);
  1070.                                 hist[hist_pos][c_pos] = code;
  1071.                                 hist[hist_pos][c_pos+1] = 0;
  1072.                                 strcat(&hist[hist_pos][0],buf);
  1073.                                 sprintf(buf,"%s%c",INS_CHAR,code);
  1074.                                 WriteCON(buf);
  1075.                             }
  1076.                             else {
  1077.                                 hist[hist_pos][c_pos] = code;
  1078.                                 sprintf(buf,"%c",code);
  1079.                                 WriteCON(buf);
  1080.                             }
  1081.                             len++;
  1082.                             c_pos++;
  1083.                         }
  1084.                         break;
  1085.                     }
  1086.                     switch (code) {
  1087.                         case 8: //Backspace
  1088.                             if (c_pos > 0) {
  1089.                                 WriteCON(CURSOR_LEFT);
  1090.                                 WriteCON(DEL_CHAR);
  1091.                                 if (len != c_pos) {
  1092.                                     strcpy(buf,&hist[hist_pos][c_pos]);
  1093.                                     hist[hist_pos][c_pos-1] = 0;
  1094.                                     strcat(&hist[hist_pos][0],buf);
  1095.                                 }
  1096.                                 c_pos--;
  1097.                                 len--;
  1098.                             }
  1099.                             break;
  1100.                         case 27: //Escape
  1101.                             c_pos = len = 0;
  1102.                             strcpy(ncom,"");
  1103.                             gotoxy(22,BottomHeight);
  1104.                             WriteCON(CLREOL);
  1105.                             break;
  1106.                         case 127: //Delete
  1107.                             if (c_pos < len) {
  1108.                                 WriteCON(DEL_CHAR);
  1109.                                 if (len != c_pos+1) {
  1110.                                     strcpy(buf,&hist[hist_pos][c_pos+1]);
  1111.                                     hist[hist_pos][c_pos] = 0;
  1112.                                     strcat(&hist[hist_pos][0],buf);
  1113.                                 }
  1114.                                 len--;
  1115.                             }
  1116.                             break;
  1117.                     }
  1118.  
  1119.                 case IDCMP_RAWKEY:
  1120.                     switch (code) {
  1121.                         case 10:
  1122.                         case 13:
  1123.                             hist[hist_pos][len] = 0;
  1124.                             strcpy(command,&hist[hist_pos][0]);
  1125.                             hist_pos++;
  1126.                             if (hist_pos >= MAX_HIST) hist_pos = 0;
  1127.                             if (hist_fill < MAX_HIST-1) hist_fill++;
  1128.                             WriteCON("\n");
  1129.                             return;
  1130.                             break;
  1131.                         case 76:
  1132.                             h_pos--;
  1133.                             if (h_pos < 0) h_pos = hist_fill;
  1134.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  1135.                             else strcpy(ncom,"");
  1136.                             c_pos = len = strlen(ncom);
  1137.                             gotoxy(22,BottomHeight);
  1138.                             sprintf(buf,"%s%s",CLREOL,ncom);
  1139.                             WriteCON(buf);
  1140.                             strcpy(&hist[hist_pos][0],ncom);
  1141.                             break;
  1142.                         case 77:
  1143.                             h_pos++;
  1144.                             if (h_pos > hist_fill) h_pos = 0;
  1145.                             if (h_pos != hist_pos) strcpy(ncom,&hist[h_pos][0]);
  1146.                             else strcpy(ncom,"");
  1147.                             c_pos = len = strlen(ncom);
  1148.                             gotoxy(22,BottomHeight);
  1149.                             sprintf(buf,"%s%s",CLREOL,ncom);
  1150.                             WriteCON(buf);
  1151.                             strcpy(&hist[hist_pos][0],ncom);
  1152.                             break;
  1153.                         case 78:
  1154.                             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT)) {
  1155.                                 c_pos = len;
  1156.                                 gotoxy(22+len,BottomHeight);
  1157.                             }
  1158.                             else if (c_pos < len) {
  1159.                                 WriteCON(CURSOR_RIGHT);
  1160.                                 c_pos++;
  1161.                             }
  1162.                             break;
  1163.                         case 79:
  1164.                             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT)) {
  1165.                                 c_pos = 0;
  1166.                                 gotoxy(22,BottomHeight);
  1167.                             }
  1168.                             else if (c_pos > 0) {
  1169.                                 WriteCON(CURSOR_LEFT);
  1170.                                 c_pos--;
  1171.                             }
  1172.                             break;
  1173.                         case 95: //Help
  1174.                             if (AmigaGuideBase) {
  1175.                                 CloseAmigaGuide(OpenAmigaGuide(&scott_guide,NULL));
  1176.                             }
  1177.                             break;
  1178.                         default:
  1179.                             break;
  1180.                     }
  1181.                     break;
  1182.  
  1183.                 case IDCMP_MENUPICK:
  1184.                     if (Menu_Handle(code,command)) {
  1185.                         strcpy(&hist[hist_pos][0],command);
  1186.                         WriteCON(command);
  1187.                         hist_pos++;
  1188.                         if (hist_pos >= MAX_HIST) hist_pos = 0;
  1189.                         if (hist_fill < MAX_HIST-1) hist_fill++;
  1190.                         return;
  1191.                     }
  1192.                     break;
  1193.  
  1194.                 case IDCMP_CLOSEWINDOW:
  1195.                     if (EasyRequest(act_w_hdl,&Quit,NULL,NULL)) {
  1196.                         close_all();
  1197.                         exit(0);
  1198.                         return;
  1199.                     }
  1200.                     break;
  1201.             }
  1202.         }
  1203.     } while (1);
  1204. }///
  1205.  
  1206. ///KeyInput
  1207. USHORT KeyInput(void)
  1208. {
  1209.     USHORT      code;
  1210.     ULONG       class;
  1211.     struct      IntuiMessage *mess;
  1212.  
  1213.     do {
  1214.         WaitPort(act_w_hdl->UserPort);
  1215.         while ((mess = (struct IntuiMessage *) GT_GetIMsg(act_w_hdl->UserPort))) {
  1216.             class = mess->Class;
  1217.             code  = mess->Code;
  1218.             GT_ReplyIMsg(mess);
  1219.             switch (class) {
  1220.                 case IDCMP_VANILLAKEY:
  1221.                     if (((code >=32) && (code <=126)) || (code == 13)) return(code);
  1222.             }
  1223.         }
  1224.     } while (1);
  1225. }///
  1226.  
  1227. ///CountPlanes
  1228. UBYTE CountPlanes(UBYTE Cols)
  1229. {
  1230.     UBYTE i;
  1231.  
  1232.     Cols--;
  1233.     for (i=0;i<8;i++) {
  1234.         if (Cols & (128>>i)) break;
  1235.     }
  1236.     return((UBYTE) (8-i));
  1237. }
  1238. ///
  1239.  
  1240. ///Init_GFX
  1241. void Init_GFX(void)
  1242. {
  1243.     int i;
  1244.     LONG maxPen=0;
  1245.  
  1246.     fseek(gfx_in_file,go[1],SEEK_SET);
  1247.     NumColours = fgetc(gfx_in_file); // how many colours
  1248.     //printf("Screen %d, Cols %d\n",1<<WBscreen->RastPort.BitMap->Depth,NumColours);
  1249.     if ((1<<WBscreen->RastPort.BitMap->Depth) < NumColours) {
  1250.         GFX_Off();
  1251.         //NOGFXPOS = TRUE;
  1252.         EasyRequest(act_w_hdl,&NoGFX,NULL,"Screen has to few colours.\nGFX will be switched off.");
  1253.         return;
  1254.     }
  1255.  
  1256.     //if (win_width < 0) {
  1257.         win_width = (int) ((BYTE) WBscreen->WBorLeft + (BYTE) WBscreen->WBorRight + gfx_width);
  1258.         win_height = (int) ((BYTE) WBscreen->WBorTop + WBscreen->Font->ta_YSize + (BYTE) WBscreen->WBorBottom + gfx_height + 1);
  1259.         win_pos_hor = w_top - win_height;
  1260.         if (win_pos_hor < (WBscreen->BarHeight + 1)) win_pos_hor = (WORD) WBscreen->BarHeight + 1;
  1261.         win_pos_ver = (WORD) ((WBscreen->Width - win_width) / 2);
  1262.     //}
  1263.  
  1264.     if (FASTCOLOURS) {
  1265.         planesN = CountPlanes(NumColours);
  1266.         //printf("Planes, Cols, Scrn: %d,%d,%d\n",planesN,NumColours,WBscreen->RastPort.BitMap->Depth);
  1267.         for (i=0;i<NumColours;i++) Pens[i] = GetRGB4(WBscreen->ViewPort.ColorMap,i);
  1268.     } // El Brutalo colours 0 through 15
  1269.     else {
  1270.         for (i=0;i<NumColours;i++) {
  1271.             if ((Pens[i] = ObtainPen(WBscreen->ViewPort.ColorMap,-1,0,0,0,PEN_EXCLUSIVE)) == -1) break;
  1272.             if (Pens[i] > maxPen) maxPen = Pens[i];
  1273.         }
  1274.         if (i != NumColours) {
  1275.             NumColours = i;
  1276.             GFX_Off();
  1277.             //NOGFXPOS = TRUE;
  1278.             EasyRequest(act_w_hdl,&NoPens,NULL,NULL);
  1279.             return;
  1280.         }
  1281.         planesN = CountPlanes(maxPen);
  1282.         //printf("Planes, Cols, Scrn: %d,%d,%d\n",planesN,NumColours,WBscreen->RastPort.BitMap->Depth);
  1283.     }
  1284.  
  1285.     //if (GFXDOUBLE) fac = 2;
  1286.     InitBitMap(&bitmapN,planesN,gfx_width,gfx_height);
  1287.     for (i=0; i<planesN; i++) {
  1288.         if ((bitmapN.Planes[i] = (PLANEPTR) AllocRaster(gfx_width,gfx_height)) == NULL) {
  1289.             planesN = i;
  1290.             GFX_Off();
  1291.             //NOGFXPOS = TRUE;
  1292.             EasyRequest(act_w_hdl,&NoGFX,NULL,"Could not allocate Bitmap.\nGFX will be switched off.");
  1293.             return;
  1294.         }
  1295.     }
  1296.  
  1297.     picture = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  1298.     rle_dat = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  1299.     overlay = (UBYTE *) MemAlloc(gfx_width * gfx_height);
  1300.     //INIT = TRUE;
  1301. }
  1302. ///
  1303.  
  1304. /// rle_decode
  1305. void rle_decode(int size)
  1306. {
  1307.     int j,i;
  1308.     int repeat,count;
  1309.  
  1310.     fread(&rle_dat[0],1,size,gfx_in_file);
  1311.     j = i = 0;
  1312.     while (j<size) {
  1313.         while (rle_dat[j] < 128) {
  1314.             picture[i++] = rle_dat[j++];
  1315.             if (j>=size) return;
  1316.         }
  1317.         repeat = rle_dat[j++]-128;
  1318.         for (count=0; count < repeat; count++) picture[i++] = rle_dat[j];
  1319.         j++;
  1320.     }
  1321. }///
  1322.  
  1323. /// rle_decodeOvl
  1324. void rle_decodeOvl(int size)
  1325. {
  1326.     int j,i;
  1327.     int repeat,count;
  1328.  
  1329.     fread(&rle_dat[0],1,size,gfx_in_file);
  1330.     j = i = 0;
  1331.     while (j<size) {
  1332.         while (rle_dat[j] < 128) {
  1333.             overlay[i++] = rle_dat[j++];
  1334.             if (j>=size) return;
  1335.         }
  1336.         repeat = rle_dat[j++]-128;
  1337.         for (count=0; count < repeat; count++) overlay[i++] = rle_dat[j];
  1338.         j++;
  1339.     }
  1340. }///
  1341.  
  1342. /// Pixel2BitmapFast
  1343. void Pixel2BitmapFast(void)
  1344. {
  1345.     int x,y,plane,byte,lbyte,pen;
  1346.     unsigned int lbit;
  1347.  
  1348.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1349.     for (y = 0; y < gfx_height; y++) {
  1350.         lbyte = y * bitmapN.BytesPerRow;
  1351.         lbit = lbyte << 3;
  1352.         for (x = 0; x < gfx_width; x++) {
  1353.             pen = picture[lbit + x];
  1354.             byte = lbyte + (x>>3);
  1355.             for (plane = 0; plane < planesN; plane++) {
  1356.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1357.             }
  1358.         }
  1359.     }
  1360. }
  1361. ///
  1362.  
  1363. /*
  1364. /// Pixel2BitmapFastDouble
  1365. void Pixel2BitmapFastDouble(void)
  1366. {
  1367.     int x,y,plane,byte,lbyte,pen;
  1368.     unsigned int lbit;
  1369.  
  1370.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1371.     for (y = 0; y < gfx_height; y++) {
  1372.         lbyte = y * bitmapN.BytesPerRow;
  1373.         lbit = lbyte << 3;
  1374.         for (x = 0; x < gfx_width; x++) {
  1375.             pen = picture[lbit + x];
  1376.             byte = lbyte + (x>>3);
  1377.             for (plane = 0; plane < planesN; plane++) {
  1378.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 192>>((x<<2)&7);
  1379.             }
  1380.         }
  1381.     }
  1382. }
  1383. ///
  1384. */
  1385.  
  1386. /// Pixel2BitmapFastOvl
  1387. void Pixel2BitmapFastOvl(void)
  1388. {
  1389.     int x,y,plane,byte,lbyte,pen;
  1390.     unsigned int lbit;
  1391.  
  1392.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1393.     for (y = 0; y < gfx_height; y++) {
  1394.         lbyte = y * bitmapN.BytesPerRow;
  1395.         lbit = lbyte << 3;
  1396.         for (x = 0; x < gfx_width; x++) {
  1397.             pen = overlay[lbit + x];
  1398.             if (pen > 15) pen = picture[lbit + x];
  1399.             byte = lbyte + (x>>3);
  1400.             for (plane = 0; plane < planesN; plane++) {
  1401.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1402.             }
  1403.         }
  1404.     }
  1405. }
  1406. ///
  1407.  
  1408. /// Pixel2BitmapPens
  1409. void Pixel2BitmapPens(void)
  1410. {
  1411.     int x,y,plane,byte,lbyte,pen;
  1412.     unsigned int lbit;
  1413.  
  1414.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1415.     for (y = 0; y < gfx_height; y++) {
  1416.         lbyte = y * bitmapN.BytesPerRow;
  1417.         lbit = lbyte << 3;
  1418.         for (x = 0; x < gfx_width; x++) {
  1419.             pen = Pens[picture[lbit + x]];
  1420.             byte = lbyte + (x>>3);
  1421.             for (plane = 0; plane < planesN; plane++) {
  1422.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1423.             }
  1424.         }
  1425.     }
  1426. }
  1427. ///
  1428.  
  1429. /// Pixel2BitmapPensOvl
  1430. void Pixel2BitmapPensOvl(void)
  1431. {
  1432.     int x,y,plane,byte,lbyte,pen;
  1433.     unsigned int lbit;
  1434.  
  1435.     for (plane=0; plane<planesN; plane++) BltClear(bitmapN.Planes[plane],RASSIZE(gfx_width,gfx_height),0);
  1436.     for (y = 0; y < gfx_height; y++) {
  1437.         lbyte = y * bitmapN.BytesPerRow;
  1438.         lbit = lbyte << 3;
  1439.         for (x = 0; x < gfx_width; x++) {
  1440.             pen = Pens[overlay[lbit + x]];
  1441.             if (pen > 15) pen = Pens[picture[lbit + x]];
  1442.             byte = lbyte + (x>>3);
  1443.             for (plane = 0; plane < planesN; plane++) {
  1444.                 if (pen & (1<<plane)) *(bitmapN.Planes[plane] + byte) |= 128>>(x&7);
  1445.             }
  1446.         }
  1447.     }
  1448. }
  1449. ///
  1450.  
  1451. /// Check_Win
  1452. void Check_Win(void)
  1453. {
  1454.     if (pic_w_hdl == NULL) {
  1455.         pic_w_hdl = (struct Window *) OpenWindowTags(NULL,WA_Title,"Graphics",WA_Left,win_pos_ver,WA_Top,win_pos_hor,
  1456.         WA_Width,win_width,WA_Height,win_height,WA_CloseGadget,FALSE,WA_DepthGadget,TRUE,WA_DragBar,TRUE,
  1457.         WA_IDCMP,IDCMP_CLOSEWINDOW,WA_CustomScreen,WBscreen,TAG_DONE);
  1458.     }
  1459. } ///
  1460.  
  1461. /// Show_Overlay
  1462. void Show_Overlay(void)
  1463. {
  1464.     rle_decodeOvl(fgetc(gfx_in_file)*256 + fgetc(gfx_in_file));
  1465.     if (FASTCOLOURS) Pixel2BitmapFastOvl();
  1466.     else Pixel2BitmapPensOvl();
  1467.     BltBitMapRastPort(&bitmapN,0,0,pic_w_hdl->RPort,WBscreen->WBorLeft,
  1468.     WBscreen->WBorTop + WBscreen->Font->ta_YSize + 1,gfx_width,gfx_height,0xC0);
  1469. }///
  1470.  
  1471. /// Show_Anim
  1472. /*
  1473. void Show_Anim(void)
  1474. {
  1475.     Check_Win();
  1476. }*/
  1477. ///
  1478.  
  1479. /// Show_Pic
  1480. void Show_Pic(void)
  1481. {
  1482.     int     i;
  1483.  
  1484.     Check_Win();
  1485.     if (pic_w_hdl) {
  1486.         NumColours = fgetc(gfx_in_file); // how many colours
  1487.         if (NumColours > 16) {
  1488.             //printf("Cols: %d\n",NumColours);
  1489.             GFX_Off();
  1490.             EasyRequest(act_w_hdl,&NoGFX,NULL,"GFX datafile corrupt\nor wrong datafile (COL).\nGFX will be switched off.");
  1491.             if (pic_w_hdl) CloseWindow(pic_w_hdl);
  1492.             pic_w_hdl = 0;
  1493.             return;
  1494.         }
  1495.         for (i=0; i<NumColours; i++) {
  1496.             CR[i].red = fgetc(gfx_in_file)>>4;
  1497.             CR[i].green = fgetc(gfx_in_file)>>4;
  1498.             CR[i].blue = fgetc(gfx_in_file)>>4;
  1499.             //printf("Pen%2d: %3d %3d %3d\n",i+4,CR[i].red,CR[i].green,CR[i].blue);
  1500.             if (FASTCOLOURS) SetRGB4(&WBscreen->ViewPort,i,CR[i].red,CR[i].green,CR[i].blue);
  1501.             else SetRGB4(&WBscreen->ViewPort,Pens[i],CR[i].red,CR[i].green,CR[i].blue);
  1502.         }
  1503.  
  1504.         rle_decode(fgetc(gfx_in_file)*256 + fgetc(gfx_in_file));
  1505.         if (FASTCOLOURS) Pixel2BitmapFast();
  1506.         else Pixel2BitmapPens();
  1507.         BltBitMapRastPort(&bitmapN,0,0,pic_w_hdl->RPort,WBscreen->WBorLeft,
  1508.         WBscreen->WBorTop + WBscreen->Font->ta_YSize + 1,gfx_width,gfx_height,0xC0);
  1509.     }
  1510. }///
  1511.  
  1512. /// Open_Pic
  1513. void Open_Pic(UBYTE pic_nr, UBYTE how)
  1514. {
  1515.     //printf("Showing Pic %d (%d)...\n",pic_nr,last_pic);
  1516.     if (go[pic_nr] != 0) { // there is definitely a picture for this room
  1517.         last_pic = pic_nr;
  1518.         fseek(gfx_in_file,go[pic_nr],SEEK_SET);
  1519.         switch (how) {
  1520.             case PIC:
  1521.                 Show_Pic();
  1522.                 break;
  1523.             case COC:
  1524.                 break;
  1525.             case OVL:
  1526.                 Show_Overlay();
  1527.                 break;
  1528.             case ANI:
  1529.                 break;
  1530.             case GOT:
  1531.                 break;
  1532.             default:
  1533.                 break;
  1534.         }
  1535.     }
  1536.     else {
  1537.         //printf("No picture for this room!\n");
  1538.         if (pic_w_hdl) {
  1539.             win_pos_ver = pic_w_hdl->LeftEdge;
  1540.             win_pos_hor = pic_w_hdl->TopEdge;
  1541.             CloseWindow(pic_w_hdl);
  1542.             pic_w_hdl = 0;
  1543.         }
  1544.         last_pic = -128;
  1545.     }
  1546. }///
  1547.  
  1548. ///Handle_Pic
  1549. BOOL Handle_Pic(int Room)
  1550. {
  1551.     int i,j,yes,ii;
  1552.  
  1553.     //printf("%d Picture(s) for Room %d.\n",rp[Room].ppr+1,MyLoc);
  1554.     if (rp[Room].ppr) {
  1555.         for (j=0; j<rp[Room].ppr; j++) {
  1556.             ii = rp[Room].what[j]-80;
  1557.             while (ii < 0) ii += 10;
  1558.             yes = 0;
  1559.             for (i=0; i<ii; i++) {
  1560.                 //printf("Switching to case %d!\n",rp[Room].loc[j][i]);
  1561.                 switch (rp[Room].loc[j][i]) {
  1562.                     case 1: // in room
  1563.                         if (Items[rp[Room].obj[j][i]].Location == MyLoc) yes++;
  1564.                         break;
  1565.                     case 2: // in inventory
  1566.                         if (Items[rp[Room].obj[j][i]].Location == 255) yes++;
  1567.                         break;
  1568.                     case 4: // in room or inventory
  1569.                         if ((Items[rp[Room].obj[j][i]].Location == 255) || (Items[rp[Room].obj[j][i]].Location == MyLoc)) yes++;
  1570.                         break;
  1571.                     case 81: // NOT in room
  1572.                         if (Items[rp[Room].obj[j][i]].Location != MyLoc) yes++;
  1573.                         break;
  1574.                     case 82: // NOT in inventory
  1575.                         if (Items[rp[Room].obj[j][i]].Location != 255) yes++;
  1576.                         break;
  1577.                     case 84: // NOT in room and NOT in inventory
  1578.                         if ((Items[rp[Room].obj[j][i]].Location != 255) && (Items[rp[Room].obj[j][i]].Location != MyLoc)) yes++;
  1579.                         break;
  1580.                     default:
  1581.                         break;
  1582.                 }
  1583.             }
  1584.             if (yes >= ii) {
  1585.                 if (rp[Room].pnr[j] == 0) { // no picture
  1586.                     //printf("Logic says: No Pic!\n");
  1587.                     if (pic_w_hdl) {
  1588.                         win_pos_ver = pic_w_hdl->LeftEdge;
  1589.                         win_pos_hor = pic_w_hdl->TopEdge;
  1590.                         CloseWindow(pic_w_hdl);
  1591.                         pic_w_hdl = 0;
  1592.                     }
  1593.                     last_pic = -128;
  1594.                     return(FALSE);
  1595.                 }
  1596.                 if (rp[Room].pnr[j] == 255) return(FALSE); // 255 = do nothing
  1597.                 if (last_pic >= 0) {
  1598.                     if ((go[last_pic] == go[rp[Room].pnr[j]])) return(FALSE);
  1599.                 }
  1600.                 //printf("Yes: %d, Last: %d - %d\n",yes,last_pic,rp[Room].pnr[j]);
  1601.                 switch ((int)(rp[Room].what[j]/10)) {
  1602.                     case PIC: // Show Pic
  1603.                         Open_Pic(rp[Room].pnr[j],PIC);
  1604.                         return(TRUE);
  1605.                     case COC: // colour cycling
  1606.                         //printf("Colour Cycling: %d\n",rp[Room].pnr[j]);
  1607.                         //return(TRUE);
  1608.                         break;
  1609.                     case OVL: // overlay picture
  1610.                         //printf("Overlay: %d\n",rp[Room].pnr[j]);
  1611.                         yes = 1;
  1612.                         if (last_pic != Room) {
  1613.                             for (i=0; i<rp[Room].ppr; i++) {
  1614.                                 if (last_pic == rp[Room].pnr[i]) {
  1615.                                     yes = 0;
  1616.                                     break;
  1617.                                 }
  1618.                             }
  1619.                         }
  1620.                         else yes = 0;
  1621.                         //printf("OVL [old pic too]: %d\n",yes);
  1622.                         if (yes) Open_Pic(Room,PIC); // basis pic is not already displayed
  1623.                         Open_Pic(rp[Room].pnr[j],OVL);
  1624.                         return(TRUE);
  1625.                         break;
  1626.                     case ANI: // animation
  1627.                         //printf("Animation: %d\n",rp[Room].pnr[j]);
  1628.                         //return(TRUE);
  1629.                         break;
  1630.                     case GOT: // GO_TREE for "Robin of Sherwood"
  1631.                         //printf("GO_TREE: %d\n",rp[Room].pnr[j]);
  1632.                         //return(TRUE);
  1633.                         break;
  1634.                     default:
  1635.                         //return(FALSE);
  1636.                         break;
  1637.                 }
  1638.             }
  1639.         }
  1640.     }
  1641.     if (last_pic >= 0) { // yes, last pic exits
  1642.         if (go[last_pic] == go[Room]) return(FALSE);
  1643.     }
  1644.     //printf("Std->Room: %d [%d is last]\n",Room,last_pic);
  1645.     Open_Pic(Room,PIC);
  1646.     return(TRUE);
  1647. }///
  1648.  
  1649. ///Speak
  1650. void Speak(char *original)
  1651. {
  1652.     LONG tlres;
  1653.  
  1654.     if (SPEECH) {
  1655.         if ((tlres = Translate((STRPTR) original,strlen(original),nartrans,narBuf)) == 0) {
  1656.             //printf("Speaking: %d: |%s|\n%d: |%s|\n",tlres,original,strlen(nartrans),nartrans);
  1657.             request->message.io_Length = strlen(nartrans);
  1658.             DoIO(request);
  1659.             //Delay(50);
  1660.         }
  1661.     }
  1662. }
  1663. ///
  1664.  
  1665. ///SpeakNum
  1666. void SpeakNum(int number)
  1667. {
  1668.     sprintf(str_buf,"%d",number);
  1669.     Speak(str_buf);
  1670. }
  1671. ///
  1672.